package com.ruoyi.common.redis.configure;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.redisson.codec.JsonJacksonCodec;

import java.io.IOException;

/**
 * Redis配置（整合Redisson）
 *
 * @author ruoyi
 */
@Configuration
@EnableCaching
@AutoConfigureBefore(RedisAutoConfiguration.class)
public class RedisConfig extends CachingConfigurerSupport {

//    @Value("${spring.redis.host:localhost}")
//    private String host;
//
//    @Value("${spring.redis.port:6379}")
//    private int port;
//
//    @Value("${spring.redis.password:}")
//    private String password;
//
//    @Value("${spring.redis.database:0}")
//    private int database;
//
//    @Value("${spring.redis.timeout:3000}")
//    private int timeout;
//
//    /**
//     * 配置Redisson客户端
//     */
//    @Bean(destroyMethod = "shutdown")
//    public RedissonClient redissonClient() throws IOException {
//        Config config = new Config();
//        // 单机模式（集群模式请参考Redisson文档配置）
//        config.useSingleServer()
//                .setAddress("redis://" + host + ":" + port)
//                .setPassword(password.isEmpty() ? null : password)
//                .setDatabase(database)
//                .setConnectTimeout(timeout)
//                .setConnectionPoolSize(64) // 连接池大小
//                .setConnectionMinimumIdleSize(10); // 最小空闲连接数
//
//        // 其他高级配置（按需添加）
//        // config.setCodec(new JsonJacksonCodec()); // 可选：替换默认编码
//        // config.setLockWatchdogTimeout(30000); // 分布式锁默认超时时间
//
//        return Redisson.create(config);
//    }
//
//    /**
//     * 使用Redisson的连接工厂替换默认工厂
//     */
//    @Bean
//    public RedisConnectionFactory redisConnectionFactory(RedissonClient redissonClient) {
//        return new RedissonConnectionFactory(redissonClient);
//    }
//
//    /**
//     * 自定义RedisTemplate（使用FastJson2序列化）
//     */
//    @Bean
//    @SuppressWarnings(value = {"unchecked", "rawtypes"})
//    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
//        RedisTemplate<Object, Object> template = new RedisTemplate<>();
//        template.setConnectionFactory(connectionFactory);
//
//        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
//
//        // Key使用String序列化
//        template.setKeySerializer(new StringRedisSerializer());
//        template.setValueSerializer(serializer);
//
//        // Hash键值序列化
//        template.setHashKeySerializer(new StringRedisSerializer());
//        template.setHashValueSerializer(serializer);
//
//        template.afterPropertiesSet();
//        return template;
//    }
@Value("${spring.redis.host:localhost}")
private String host;

    @Value("${spring.redis.port:6379}")
    private int port;

    @Value("${spring.redis.password:}")
    private String password;

    @Value("${spring.redis.database:0}")
    private int database;

    @Value("${spring.redis.timeout:3000}")
    private int timeout;

    /**
     * 配置Redisson客户端（使用JSON编码）
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() throws IOException {
        Config config = new Config();
        // 单机模式配置
        config.useSingleServer()
                .setAddress("redis://" + host + ":" + port)
                .setPassword(password.isEmpty() ? null : password)
                .setDatabase(database)
                .setConnectTimeout(timeout)
                .setConnectionPoolSize(64)
                .setConnectionMinimumIdleSize(10);

        // 设置JSON编码，存储为字符串
        config.setCodec(new JsonJacksonCodec());

        return Redisson.create(config);
    }

    /**
     * 使用Redisson的连接工厂
     */
    @Bean
    public RedisConnectionFactory redisConnectionFactory(RedissonClient redissonClient) {
        return new RedissonConnectionFactory(redissonClient);
    }

    /**
     * 自定义RedisTemplate（使用Jackson序列化字符串）
     */
    @Bean
    @SuppressWarnings(value = {"unchecked", "rawtypes"})
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 使用Jackson序列化（存储为JSON字符串）
        GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();

        // Key使用String序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash键值序列化
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}